Conventional memory devices have relied upon external test circuitry to generate row and column addresses for testing the functionality of individual memory cells in memory devices. This, however, requires complicated programming of the test equipment as well as the inclusion of circuitry in the tester to generate memory addresses. The test equipment must be programmed with each memory address to be tested for a given memory device. Each time a new memory device is to be tested a new set of memory addresses must be programmed into the test equipment. The additional circuitry required to generate memory addresses within the tester also contributes to increased costs, both initial and maintenance, of the test equipment. The test capabilities of the tester are also limited because conventional drive circuitry is limited by the number of devices it can test in parallel. For example, when testing 16 memory devices, each having 20 address pins, the test equipment must drive 320 pins. This can require significant resources in the tester's drive circuitry.
In addition, conventional test equipment and conventional memory devices have further limitations. For example, some conventional test equipment was designed to use 16 address pins. As technology progressed, some memory devices began using additional address bits, requiring additional address pins, for example, 20 pins. If a conventional memory device having 20 address pins were to be tested using conventional test equipment designed to use only 16 address pins, additional test equipment would be needed to control the 4 pins not addressed by the conventional test equipment.
On-chip counters that generate memory addresses are in use in some DRAMs as part of a refresh circuitry. During normal operation of the DRAM, a data bit contained within a memory cell must be periodically refreshed. This is because the data bit is stored in a capacitor that has a slight leakage current. The refresh operation restores the data to its full logic 1 or logic 0 level. As part of this operation a refresh counter cycles through the row addresses, with additional circuitry refreshing each row address in turn as its address is specified by the refresh counter.
A refresh counter, however, is limited to generating non-redundant addresses in logical order. They do not generate redundant row addresses, and do not generate row addresses in an order that corresponds to the physical layout of the memory cells (i.e., physical order).
It is extremely important that during testing, addresses can be generated in physical order. Due to design constraints, it is not unusual for the memory array to have adjacent memory cells that have non-sequential memory addresses. For example, a memory cell having the address of row two, column six might be physically adjacent to a memory cell having the address of row three, column six. As a result of being physically adjacent, the memory addresses of row two, column six and row three, column six would then be in physical sequence/order.
Further, one of the tests of functionality checks for charge leakage between adjacent memory cells. In the example above, the test would check to see if a charge applied to the memory cell having the address of row two, column six, would appear on the adjacent memory cell having the address of row three, column six, or vice versa. This could result if a short occurred between the memory cells, indicating a defect in the memory device.
This test is put into practice by writing to one row/column, and then reading an adjacent row/column. In order to implement this, a counter must be able to generate memory addresses in physical order for the writing and then reading of the memory cells. When testing for functionality, it does no good to write to, for example, row one, column one and read from row two, column one (two memory cells in logical sequence/order), to check for leakage if the two memory cells are not adjacent (i.e., in physical sequence/order), as they rarely are. This is because the charge leakage, if any, usually only occurs between adjacent cells. Because refresh counters generate row addresses in a logical order, and do not generate row addresses in physical order, refresh counters are unsuited for this type of test.
As mentioned above, refresh counters are unable to generate memory addresses for redundant rows. Most memory chips today contain extra rows and columns of memory cells. When a defect is detected in a row/column of memory cells, additional circuitry deactivates the defective row/column and activates one of the redundant rows/columns. For example, a memory chip may contain four thousand and one hundred rows of memory cells. Of the four thousand and one hundred rows, rows zero through four thousand and ninety five, for example, are considered "non-redundant" memory space, and are used during normal operation. Rows four thousand and ninety six to four thousand and ninety nine would then be considered "redundant" rows, and would only be used if a defect is found in one of the "non-redundant" rows. This same architecture also applies to columns.
If a defect were detected in row twelve, for example, row four thousand and ninety six would be used in its place. Significantly, the memory address of "row twelve" would not become void. Instead, the memory address of "row twelve" would be reassigned by the additional circuitry to row four thousand and ninety six. Thus, data would continue to be written to and read from the memory address of "row twelve", but this data would be physically located in row four thousand and ninety six.
In keeping with this architecture, refresh counters are only needed to generate memory addresses within the "non-redundant" memory space. The refresh counter never needs to generate a memory address of a "redundant" row because either the redundant row does not contain data, and therefore no memory address needs to be generated because no data needs to be refreshed, or the redundant row does contain data needing periodic refreshing, but has been assigned a memory address from the "non-redundant" memory space, and generation of a "non-redundant" memory address by the refresh counter refreshes the redundant row.
Because refresh counters are not capable of generating memory addresses for the "redundant" rows, refresh counters are not suitable to test the functionality of memory cells within a memory device.